# Source code for BigDFT.PDoS

```
"""
This module offers a suite of tools for calculating and analyzing the projected
density of states (PDoS) in molecular systems. It provides functionality to
extract projection information from cubic and linear scaling PDoS calculations,
and compute weights associated with each projection.
Examples:
The module includes two example functions (_example_cubic and _example_linear)
to demonstrate usage with cubic and linear scaling PDoS calculations,
respectively.
"""
# Constants
PROJECTION_THRESHOLD = 0.3
[docs]def cubic_projection_info(log):
"""
Extracts projection information from a cubic scaling Projected Density of
States (PDoS) calculation, as performed in a BigDFT run.
This function processes the output log file from a cubic scaling BigDFT
calculation to map each atom in the system to its projections, such
as 's', 'px', 'py', 'pz', etc. The function is designed to work with the
specific structure of BigDFT log files, particularly extracting information
from the 'Mulliken Charge Population Analysis' section.
Args:
log (BigDFT.Logfiles.Logfile): A BigDFT log file object, containing
the results of a cubic scaling calculation with the pdos option on.
Returns:
dict of dict of list: A nested dictionary where the
first key is the atomic symbol, and the second key is the projection
type. The value is a list of indices, each corresponding to a
projection of that type for the atom.
For example: {'C': {'s': [0], 'px': [1], 'py': [2], 'pz': [3]}}.
"""
from BigDFT.Systems import system_from_log
from collections import defaultdict
sys = system_from_log(log, fragmentation="full")
proj_list = defaultdict(lambda: defaultdict(list))
charge_analy = log.log["Mulliken Charge Population Analysis"]
i = 0
for at, proj in zip(sys.get_atoms(), charge_analy):
for p in proj:
if p == "Center Quantities":
continue
proj_list[at.sym][p].append(i)
i += 1
return _defaultdict_to_dict(proj_list)
[docs]def cubic_projection_weights(log, proj_info, log_dir="."):
"""
Calculates the weights associated with each projection from a cubic scaling
Projected Density of States (PDoS) calculation.
This function interprets the PDoS data stored in a BigDFT log file to
compute the weights of different atomic projections (e.g., 's', 'px', 'py',
'pz') for each orbital. It utilizes the projection information obtained
from `cubic_projection_info` and the PDoS data file ('pdos.dat').
Args:
log (BigDFT.Logfiles.Logfile): The BigDFT log file object from a cubic
scaling PDoS calculation.
proj_info (dict): A dictionary mapping atomic symbols to projection
types and indices, as returned by `cubic_projection_info`.
log_dir (str, optional): The directory where the BigDFT log file is
located. Defaults to the current directory (".").
Returns:
list of dict: A list where each element corresponds to an
orbital. Each element is a dict, mapping atomic types to another dict,
which in turn maps projections to their weights. For example, if you
want the weight of the first orbital for the 's' projection of Carbon,
it would be accessed as weights[0]['C']['s'].
"""
from os.path import join
from collections import defaultdict
weights = []
# Map back from index to symbol / projector type
reverse_lookup = {}
for k, v in proj_info.items():
for p, idx in v.items():
for i in idx:
reverse_lookup[i] = (k, p)
with open(join(log_dir, log.data_directory, "pdos.dat")) as ifile:
for line in ifile:
vals = [float(x) for x in line.split()]
wdict = defaultdict(lambda: defaultdict(float))
i = 0
for j, w in enumerate(vals):
if j not in reverse_lookup: # Sometimes padding
continue
sym, p = reverse_lookup[j]
wdict[sym][p] += w
weights.append(wdict)
return _defaultdict_to_dict(weights)
[docs]def compute_weight(evec, sks_evec, orb_idx, proj_idx):
"""
Computes the weight of a specific projection for a given orbital in the
projected density of states (PDoS) calculation, typically used in the
linear scaling mode.
This function calculates the contribution of a specified set of projections
(identified by their indices) to a particular orbital, based on the
eigenvectors of the system. The function allows for optional inclusion of
the overlap matrix (s) and the density matrix (k) if you're doing
Mulliken analysis or projecting out virtuals, respectively.
Args:
evec (numpy.array): Array of eigenvectors, where each column represents
an eigenvector of the system.
evec (numpy.array): Overlap * Density * Overlap * evec. Overlap
allows you to do a Mulliken projection, and Density can be used
to filter in energy. If you're doing Lowdin, just use the
density. If you don't need to filter in energy, the identity
matrix can be used for the density.
orb_idx (int): Index of the orbital for which the weight is being
computed.
proj_idx (list of int): List of indices corresponding to the
projections included in the weight calculation.
Returns:
(float): the calculated weight.
"""
from numpy import trace
# Project
seig_l = evec[:, orb_idx:orb_idx+1]
seig_r = sks_evec[:, orb_idx:orb_idx+1]
return trace(seig_l[proj_idx, :].T @ (seig_r)[proj_idx, :]).item()
[docs]def linear_projection_info(log, thresh=PROJECTION_THRESHOLD):
"""
Analyze and categorize projection types for each atom in the system based
on electrostatic multipole information from a given log file.
This function processes the electrostatic multipoles associated with atoms
in a system and classifies each support function (such as 's', 'px', 'py',
'pz', 'dxy', etc.) based on their multipole expansion.
Args:
log (BigDFT.Logfiles.Logfile): The log file object from a BigDFT run.
thresh (float): the threshold used for determining the character
of a multipole.
Returns:
dict of dict of list: A nested dictionary where the first key is the
atomic symbol, the second key is the projection type, and the value is
a list of indices associated with that projection type for the given
atom.
Example: {'H': {'s': [0]}, 'O': {'px': [1], 'py': [2], 'pz': [3]'}}
Raises:
ValueError: If the projection type cannot be determined for an atom
based on the heuristic criteria.
"""
def guess_proj_type(atm, thresh):
if abs(abs(atm["q1"][0]) - 1) < thresh:
ptype = 'py'
elif abs(abs(atm["q1"][1]) - 1) < thresh:
ptype = 'pz'
elif abs(abs(atm["q1"][2]) - 1) < thresh:
ptype = 'px'
elif abs(abs(atm["q0"][0]) - 1) < thresh:
ptype = 's'
elif abs(abs(atm["q2"][0]) - 1) < thresh:
ptype = 'dxy'
elif abs(abs(atm["q2"][1]) - 1) < thresh:
ptype = 'dyz'
elif abs(abs(atm["q2"][2]) - 1) < thresh:
ptype = 'dz^2'
elif abs(abs(atm["q2"][3]) - 1) < thresh:
ptype = 'dxz'
elif abs(abs(atm["q2"][4]) - 1) < thresh:
ptype = 'dx^2-y^2'
else:
raise ValueError("Can't figure out " + str(atm))
return ptype
from warnings import warn
from collections import defaultdict
proj_info = defaultdict(lambda: defaultdict(list))
# Use the multipole information for the compute matching
mp = log.electrostatic_multipoles
for pole in mp["values"]:
pole["units"] = mp["units"]
# Get the Multipole Descriptions
gsfm = log.log["Gross support functions moments"]
mp_info = gsfm["Multipole coefficients"]["values"]
for i, atm in enumerate(mp_info):
sym = atm["sym"].split("-")[0]
ptype = guess_proj_type(atm, thresh)
if atm["type"] != "unknown":
ltype = atm["type"].replace("_", "")
if ltype != ptype:
warn("Uncertainty about support function character" + str(atm))
ptype = ltype
proj_info[sym][ptype].append(i)
return _defaultdict_to_dict(proj_info)
[docs]def linear_projection_weights(evec, proj_info, s, k):
"""
Computes the weights associated with a set of projections for each
eigenvalue in a linear scaling Projected Density of States (PDoS)
calculation.
This function uses the eigenvectors and eigenvalues of a system, along with
projection information (such as atomic symbols and projection types), to
calculate the contribution of these projections to each eigenvalue.
The function allows for inclusion of the overlap matrix (s) and the
density matrix (k) if you're doing Mulliken analysis or projecting out
virtuals, respectively. If you're doing Lowdin, pass the Lowdin
orthogonalized eigenvectors and the identity matrix for s. You're doing
Mulliken, and don't want to project out virtuals, pass the overlap matrix
as K.
Args:
evec (numpy.array): Array of eigenvectors, where each column represents
an eigenvector of the system.
proj_info (dict): Dictionary mapping atom symbols to projections, and
projections to indices, as obtained from `linear_projection_info`.
s (numpy.array): Overlap matrix, used in the calculation of the weights
k (numpy.array): Density matrix, used in the calculation of the weights
Returns:
list of dict: A list where each element corresponds to an
eigenvalue. Each element is a dict, mapping atomic types to another
dict, which in turn maps projections to their computed weights. For
example, weights[0]['C']['s'] would access the weight of 's' projection
for Carbon for the first eigenvalue.
"""
from collections import defaultdict
sks = s @ k @ s
sks_evec = sks @ evec
weights = []
for i in range(evec.shape[1]):
wdict = defaultdict(lambda: defaultdict(float))
for atm, proj in proj_info.items():
for p in proj:
wdict[atm][p] += compute_weight(evec, sks_evec, i,
proj_info[atm][p])
weights.append(wdict)
return _defaultdict_to_dict(weights)
[docs]def compute_fragment_weights(sys, log, evec, evals, s, k):
"""
Computes the weights associated with fragments in a system for each
eigenvalue for a Fragment Projected Density of States (PDoS) calculation.
Args:
sys (BigDFT.Systems.System): The system object as defined in BigDFT,
representing the fragments of the system.
log (BigDFT.Logfiles.Logfile): The log file object from a BigDFT run
computed in the linear scaling mode.
evec (numpy.array): Array of eigenvectors, where each column represents
an eigenvector of the system.
s (numpy.array): Overlap matrix, used in the calculation of the weights
k (numpy.array): Density matrix, used in the calculation of the weights
Returns:
list of dict: A list where each element corresponds to an
eigenvalue. Each element is a dict, mapping fragment identifiers to
their computed weights. For example, weights[0]['HOH:1'] accesses the
weight of fragment 'HOH:1' for the first eigenvalue.
"""
from BigDFT.PostProcessing import BigDFTool
tool = BigDFTool()
fidx = tool.get_frag_indices(sys, log)
weights = linear_projection_weights(evec, {"frag": fidx}, s=s, k=k)
# Eliminate intermediate dictionary
for i, v in enumerate(weights):
weights[i] = v["frag"]
return _defaultdict_to_dict(weights)
def _defaultdict_to_dict(d):
"""
Recursively converts a nested defaultdict or a list of defaultdicts to a
nested dict or a list of dicts, respectively.
Args:
d (defaultdict, dict, list): A defaultdict, a standard dict, or a list.
The defaultdict may be nested and the list may contain defaultdicts
or nested defaultdicts.
Returns:
dict or list: A standard dict or a list of dicts with all nested
defaultdicts converted into dicts. If the input is a standard dict or
a list containing standard dicts, it returns the input as-is.
"""
from collections import defaultdict
if isinstance(d, defaultdict):
return {k: _defaultdict_to_dict(v) for k, v in d.items()}
elif isinstance(d, dict):
return {k: _defaultdict_to_dict(v) for k, v in d.items()}
elif isinstance(d, list):
return [_defaultdict_to_dict(v) for v in d]
return d
[docs]def _example_cubic():
# System
from BigDFT.Database.Molecules import get_molecule
sys = get_molecule("H2O")
# Input file
from BigDFT.Inputfiles import Inputfile
inp = Inputfile()
inp.set_hgrid(0.4)
inp.set_xc("PBE")
inp.calculate_pdos()
# Calculate
from BigDFT.Calculators import SystemCalculator
code = SystemCalculator(skip=True, verbose=False)
log = code.run(sys=sys, input=inp, name="pdos-C")
# Get weights
proj_list = cubic_projection_info(log)
weights = cubic_projection_weights(log, proj_list)
print(weights[0]["O"]["s"])
print(weights[1]["H"]["s"])
[docs]def _example_linear():
# System
from BigDFT.Database.Molecules import get_molecule
sys = get_molecule("H2O")
# Input file
from BigDFT.Inputfiles import Inputfile
inp = Inputfile()
inp.set_hgrid(0.4)
inp.set_xc("PBE")
inp["import"] = "linear"
inp["lin_general"] = {"support_function_multipoles": True}
from BigDFT.Calculators import SystemCalculator
code = SystemCalculator(skip=True, verbose=False)
log = code.run(sys=sys, input=inp, name="pdos-L")
# Read the matrices
from BigDFT.PostProcessing import BigDFTool
tool = BigDFTool()
h = tool.get_matrix_h(log)
s = tool.get_matrix_s(log)
k = tool.get_matrix_k(log)
# Diagonalize
from scipy.linalg import eigh
evals, evec = eigh(h.todense(), b=s.todense())
# Get the weights
proj_info = linear_projection_info(log)
weights = linear_projection_weights(evec, proj_info, s=s, k=0.5 * k)
print(weights[0]["O"]["s"])
print(weights[1]["H"]["s"])
if __name__ == "__main__":
_example_linear()
_example_cubic()
```